# 阶乘的和 (不懂)
# S = 5! + 6! + 7!
#   = 5! + 5! * 6 + 5! * 6 * 7
#   = 5! * (1 + 6 + 6 * 7)
#   = 120 * (7 + 42)
#   = 120 * (49)


def max_factor(arr):
    """我的方法, 超时"""
    min_num, max_num = min(arr), max(arr)
    factor, s = 1, 0
    min_factorial = 1  # 最小数字的阶乘, 是一个可能的解
    res = 1
    for i in range(1, max_num + 1):
        factor *= i
        if i == min_num:
            res = factor
            min_factorial = factor
        while i in arr:
            s += factor
            arr.remove(i)

    if s // min_factorial > min_factorial:
        factorial = min_factorial
        while min_factorial <= s // factorial:
            factor += 1
            min_factorial *= factor
            if s % min_factorial == 0:
                res = max(res, factor)
    return res


def max_factor_opt(arr):
    """
    例如 arr = [2, 2, 2, 3]
    S = 2! + 2! + 2! + 3!
      = 2! * 3 + 2 * 3
    显然最小的数字2!一定是S的一个因数
    那么我们可以测试3!, 3!由于有3个2!相加, 所以3也一定是S的一个因数
    再例如: arr = [2, 2, 2, 3, 4]
    S = 2! + 2! + 2! + 3! + 4!
      = 2! * 3 + 2 * 3 + 2 * 3 * 4 = 36
    显然3!一定是S其中的一个因数, 但是4!不是
    再例如: arr = [2, 2, 2, 3, 3, 3, 4]
    S = 2! * 3 + 3! * 3 + 4!
      = 3! + 3! * 3 + 4!
      = 3! * 4 + 4!
    显然4!也是是S的因数.
    我们假设数组从小到大排列:
    可以分析, 数组中最小的数字A[0]!必然是S的一个因数.
    使用一个计数器count来记录最小的A[0]的个数, 如果数组中A[0]的个数 = A[1], 那么所有A[0]的和可以写为 A[0] * A[1] = A[1]!
    所以A[1]!也必然是S的一个因数了. 以此类推即可求的最大的m
    """

    arr.sort()
    res = arr[0]
    count = 0  # 计数器
    test = res + 1  # 测试的数字
    while True:
        for i in arr:
            if i == res:
                count += 1
        if count % test == 0:
            count /= test
            res = test
            test += 1
        else:
            break
    return res


if __name__ == '__main__':
    # n = int(input())
    # inp = list(map(int, input().split()))

    print(max_factor([2, 2, 2]))
    print(max_factor_opt([2, 2, 2, 3, 4]))
